{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 非线性偏微分方程的数据驱动解\n",
    "\n",
    "--------Data-driven Solutions of Nonlinear Partial Differential Equations\n",
    "\n",
    "在这篇分为两部分的论文的[第一部分](https://arxiv.org/abs/1711.10561)中，我们将重点讨论计算**一般形式偏微分方程**(partial differential equations of the general form)的数据驱动解\n",
    "$$\n",
    "\\large u_t + \\cal N[u] = 0, x\\in Ω, t \\in [0,T],\n",
    "$$\n",
    "其中 $u(t,x)$ 表示潜在（隐藏）解，$\\cal N[⋅]$ 是一个**非线性微分算子**(nonlinear differential operator)，$Ω$ 是 $R^D$ 的子集。接下来，我们提出了两类不同的算法，即**连续时间模型和离散时间模型**(continuous and discrete time models)，并通过不同的基准问题来突出它们的性质和性能。[这里](https://github.com/maziarraissi/PINNs)提供了所有代码和数据集。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 连续时间模型\n",
    "\n",
    "--------Continuous Time Models\n",
    "\n",
    "我们定义 $f(t,x)$ 为\n",
    "$$\n",
    "\\large f := u_t + \\cal N[u],\n",
    "$$\n",
    "\n",
    "然后用深度神经网络逼近 $u(t,x)$ 。这个假设产生了一个[物理信息神经网络](https://arxiv.org/abs/1711.10561) $f(t,x)$ 。这个网络可以通过计算图上的演算得到：[反向传播](http://colah.github.io/posts/2015-08-Backprop/)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 示例1(Burgers方程)\n",
    "\n",
    "作为一个例子，让我们考虑[Burgers方程](https://en.wikipedia.org/wiki/Burgers'_equation)。在一维空间中，Burger方程的Dirichlet边界条件如下\n",
    "$$\n",
    "\\begin{align}\n",
    "& \\large u_t + uu_x - (0.01/\\pi)u_{xx} = 0, x \\in [-1,1], t \\in [0,1],\\\\\n",
    "& \\large u(0,x) = -sin(\\pi x),\\\\\n",
    "& \\large u(t,-1) = u(t,1) = 0.\\\\\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "\n",
    "\n",
    "让我们定义 $f(t,x)$ 为\n",
    "$$\n",
    "\\large f := u_t + uu_x - (0.01/\\pi)u_{xx},\n",
    "$$\n",
    "\n",
    "然后用深度神经网络逼近 $u(t,x)$ 。为了强调这个想法的简单性，让我们用Python来实现它，只需要一点点[Tensorflow](https://www.tensorflow.org/)。为此， $u(t,x)$ 可以简单地定义为\n",
    "\n",
    "```python\n",
    "def u(t, x):\n",
    "    u = neural_net(tf.concat([t,x],1), weights, biases)\n",
    "    return u\n",
    "```\n",
    "\n",
    "相应地，[物理信息神经网络](https://arxiv.org/abs/1711.10561)$f(t,x)$ 采用以下形式\n",
    "\n",
    "```python\n",
    "def f(t, x):\n",
    "    u = u(t, x)\n",
    "    u_t = tf.gradients(u, t)[0]\n",
    "    u_x = tf.gradients(u, x)[0]\n",
    "    u_xx = tf.gradients(u_x, x)[0]\n",
    "    f = u_t + u*u_x - (0.01/tf.pi)*u_xx\n",
    "    return f\n",
    "```\n",
    "\n",
    "通过最小化均方误差损失，可以学习神经网络 $u(t,x)$ 和 $f(t,x)$ 之间的共享参数\n",
    "$$\n",
    "\\begin{align}\n",
    "& MSE = MSE_u + MSF_f,\\\\\n",
    "& MSE_u = \\frac 1 {N_u} \\sum^{N_u}_{i=1} |u(t^i_u, x^i_u) - u^i|^2,\\\\\n",
    "& MSE_f = \\frac 1 {N_f} \\sum^{N_f}_{i=1} |f(t^i_f, x^i_f)|^2.\\\\\n",
    "\\end{align}\n",
    "$$\n",
    "这里，$\\{ {t^i_u, x^i_u, u^i} \\}^{N_u}_{i=1}$ 表示 $u(t,x)$ 上的初始和边界训练数据，$\\{{t^i_f,x^i_f}\\}^{N_f}_{i=1}$指定 $f(t,x)$ 的配置点。损失 $MSE_u$ 对应于初始和边界数据，而 $MSE_f$ 在有限的配置点集上强制执行Burgers方程施加的结构。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install pyDOE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参考代码： ---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "# sys.path.insert(0, '../Utilities/')\n",
    "\n",
    "import torch\n",
    "from collections import OrderedDict\n",
    "\n",
    "from pyDOE import lhs\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io\n",
    "from scipy.interpolate import griddata\n",
    "# from plotting import newfig, savefig\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "import matplotlib.gridspec as gridspec\n",
    "import time\n",
    "\n",
    "np.random.seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.10.1'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CUDA support \n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Physics-informed Neural Networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the deep neural network\n",
    "class DNN(torch.nn.Module):\n",
    "    def __init__(self, layers):\n",
    "        super(DNN, self).__init__()\n",
    "        \n",
    "        # parameters\n",
    "        self.depth = len(layers) - 1\n",
    "        \n",
    "        # set up layer order dict\n",
    "        self.activation = torch.nn.Tanh\n",
    "        \n",
    "        layer_list = list()\n",
    "        for i in range(self.depth - 1): \n",
    "            layer_list.append(\n",
    "                ('layer_%d' % i, torch.nn.Linear(layers[i], layers[i+1]))\n",
    "            )\n",
    "            layer_list.append(('activation_%d' % i, self.activation()))\n",
    "            \n",
    "        layer_list.append(\n",
    "            ('layer_%d' % (self.depth - 1), torch.nn.Linear(layers[-2], layers[-1]))\n",
    "        )\n",
    "        layerDict = OrderedDict(layer_list)\n",
    "        \n",
    "        # deploy layers\n",
    "        self.layers = torch.nn.Sequential(layerDict)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.layers(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the physics-guided neural network\n",
    "class PhysicsInformedNN():\n",
    "    def __init__(self, X_u, u, X_f, layers, lb, ub, nu):\n",
    "        \n",
    "        # boundary conditions\n",
    "        self.lb = torch.tensor(lb).float().to(device)\n",
    "        self.ub = torch.tensor(ub).float().to(device)\n",
    "        \n",
    "        # data\n",
    "        self.x_u = torch.tensor(X_u[:, 0:1], requires_grad=True).float().to(device)\n",
    "        self.t_u = torch.tensor(X_u[:, 1:2], requires_grad=True).float().to(device)\n",
    "        self.x_f = torch.tensor(X_f[:, 0:1], requires_grad=True).float().to(device)\n",
    "        self.t_f = torch.tensor(X_f[:, 1:2], requires_grad=True).float().to(device)\n",
    "        self.u = torch.tensor(u).float().to(device)\n",
    "        \n",
    "        self.layers = layers\n",
    "        self.nu = nu\n",
    "        \n",
    "        # deep neural networks\n",
    "        self.dnn = DNN(layers).to(device)\n",
    "        \n",
    "        # optimizers: using the same settings\n",
    "        self.optimizer = torch.optim.LBFGS(\n",
    "            self.dnn.parameters(), \n",
    "            lr=1.0, \n",
    "            max_iter=50000, \n",
    "            max_eval=50000, \n",
    "            history_size=50,\n",
    "            tolerance_grad=1e-5, \n",
    "            tolerance_change=1.0 * np.finfo(float).eps,\n",
    "            line_search_fn=\"strong_wolfe\"       # can be \"strong_wolfe\"\n",
    "        )\n",
    "\n",
    "        self.iter = 0\n",
    "        \n",
    "    def net_u(self, x, t):  \n",
    "        u = self.dnn(torch.cat([x, t], dim=1))\n",
    "        return u\n",
    "    \n",
    "    def net_f(self, x, t):\n",
    "        \"\"\" The pytorch autograd version of calculating residual \"\"\"\n",
    "        u = self.net_u(x, t)\n",
    "        \n",
    "        u_t = torch.autograd.grad(\n",
    "            u, t, \n",
    "            grad_outputs=torch.ones_like(u),\n",
    "            retain_graph=True,\n",
    "            create_graph=True\n",
    "        )[0]\n",
    "        u_x = torch.autograd.grad(\n",
    "            u, x, \n",
    "            grad_outputs=torch.ones_like(u),\n",
    "            retain_graph=True,\n",
    "            create_graph=True\n",
    "        )[0]\n",
    "        u_xx = torch.autograd.grad(\n",
    "            u_x, x, \n",
    "            grad_outputs=torch.ones_like(u_x),\n",
    "            retain_graph=True,\n",
    "            create_graph=True\n",
    "        )[0]\n",
    "        \n",
    "        f = u_t + u * u_x - self.nu * u_xx\n",
    "        return f\n",
    "    \n",
    "    def loss_func(self):\n",
    "        self.optimizer.zero_grad()\n",
    "        \n",
    "        u_pred = self.net_u(self.x_u, self.t_u)\n",
    "        f_pred = self.net_f(self.x_f, self.t_f)\n",
    "        loss_u = torch.mean((self.u - u_pred) ** 2)\n",
    "        loss_f = torch.mean(f_pred ** 2)\n",
    "        \n",
    "        loss = loss_u + loss_f\n",
    "        \n",
    "        loss.backward()\n",
    "        self.iter += 1\n",
    "        if self.iter % 100 == 0:\n",
    "            print(\n",
    "                'Iter %d, Loss: %.5e, Loss_u: %.5e, Loss_f: %.5e' % (self.iter, loss.item(), loss_u.item(), loss_f.item())\n",
    "            )\n",
    "        return loss\n",
    "    \n",
    "    def train(self):\n",
    "        self.dnn.train()\n",
    "                \n",
    "        # Backward and optimize\n",
    "        self.optimizer.step(self.loss_func)\n",
    "\n",
    "            \n",
    "    def predict(self, X):\n",
    "        x = torch.tensor(X[:, 0:1], requires_grad=True).float().to(device)\n",
    "        t = torch.tensor(X[:, 1:2], requires_grad=True).float().to(device)\n",
    "\n",
    "        self.dnn.eval()\n",
    "        u = self.net_u(x, t)\n",
    "        f = self.net_f(x, t)\n",
    "        u = u.detach().cpu().numpy()\n",
    "        f = f.detach().cpu().numpy()\n",
    "        return u, f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nu = 0.01/np.pi\n",
    "noise = 0.0        \n",
    "\n",
    "N_u = 100\n",
    "N_f = 10000\n",
    "layers = [2, 20, 20, 20, 20, 20, 20, 20, 20, 1]\n",
    "\n",
    "data = scipy.io.loadmat('data/burgers_shock.mat')\n",
    "\n",
    "t = data['t'].flatten()[:,None]\n",
    "x = data['x'].flatten()[:,None]\n",
    "Exact = np.real(data['usol']).T\n",
    "\n",
    "X, T = np.meshgrid(x,t)\n",
    "\n",
    "X_star = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
    "u_star = Exact.flatten()[:,None]              \n",
    "\n",
    "# Doman bounds\n",
    "lb = X_star.min(0)\n",
    "ub = X_star.max(0)    \n",
    "\n",
    "xx1 = np.hstack((X[0:1,:].T, T[0:1,:].T))\n",
    "uu1 = Exact[0:1,:].T\n",
    "xx2 = np.hstack((X[:,0:1], T[:,0:1]))\n",
    "uu2 = Exact[:,0:1]\n",
    "xx3 = np.hstack((X[:,-1:], T[:,-1:]))\n",
    "uu3 = Exact[:,-1:]\n",
    "\n",
    "X_u_train = np.vstack([xx1, xx2, xx3])\n",
    "X_f_train = lb + (ub-lb)*lhs(2, N_f)\n",
    "X_f_train = np.vstack((X_f_train, X_u_train))\n",
    "u_train = np.vstack([uu1, uu2, uu3])\n",
    "\n",
    "idx = np.random.choice(X_u_train.shape[0], N_u, replace=False)\n",
    "X_u_train = X_u_train[idx, :]\n",
    "u_train = u_train[idx,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = PhysicsInformedNN(X_u_train, u_train, X_f_train, layers, lb, ub, nu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 100, Loss: 9.29035e-02, Loss_u: 6.07754e-02, Loss_f: 3.21281e-02\n",
      "Iter 200, Loss: 5.62758e-02, Loss_u: 4.10913e-02, Loss_f: 1.51845e-02\n",
      "Iter 300, Loss: 3.25851e-02, Loss_u: 2.19337e-02, Loss_f: 1.06513e-02\n",
      "Iter 400, Loss: 1.76453e-02, Loss_u: 9.66416e-03, Loss_f: 7.98113e-03\n",
      "Iter 500, Loss: 7.40109e-03, Loss_u: 3.70301e-03, Loss_f: 3.69808e-03\n",
      "Iter 600, Loss: 3.06777e-03, Loss_u: 1.36563e-03, Loss_f: 1.70213e-03\n",
      "Iter 700, Loss: 1.54545e-03, Loss_u: 5.64569e-04, Loss_f: 9.80878e-04\n",
      "Iter 800, Loss: 8.33278e-04, Loss_u: 2.62620e-04, Loss_f: 5.70658e-04\n",
      "Iter 900, Loss: 5.86433e-04, Loss_u: 1.65065e-04, Loss_f: 4.21368e-04\n",
      "Iter 1000, Loss: 4.34520e-04, Loss_u: 1.22842e-04, Loss_f: 3.11678e-04\n",
      "Iter 1100, Loss: 3.14403e-04, Loss_u: 1.01526e-04, Loss_f: 2.12876e-04\n",
      "Iter 1200, Loss: 2.46424e-04, Loss_u: 7.95268e-05, Loss_f: 1.66897e-04\n",
      "Iter 1300, Loss: 2.07988e-04, Loss_u: 6.36699e-05, Loss_f: 1.44318e-04\n",
      "Iter 1400, Loss: 1.72997e-04, Loss_u: 4.26886e-05, Loss_f: 1.30308e-04\n",
      "Iter 1500, Loss: 1.49713e-04, Loss_u: 3.88695e-05, Loss_f: 1.10843e-04\n",
      "Iter 1600, Loss: 1.30774e-04, Loss_u: 2.84942e-05, Loss_f: 1.02279e-04\n",
      "Iter 1700, Loss: 1.12583e-04, Loss_u: 2.15810e-05, Loss_f: 9.10018e-05\n",
      "Iter 1800, Loss: 9.61888e-05, Loss_u: 1.73779e-05, Loss_f: 7.88109e-05\n",
      "Iter 1900, Loss: 8.48980e-05, Loss_u: 1.35712e-05, Loss_f: 7.13268e-05\n",
      "Iter 2000, Loss: 7.37043e-05, Loss_u: 9.52552e-06, Loss_f: 6.41788e-05\n",
      "Iter 2100, Loss: 6.50616e-05, Loss_u: 8.21515e-06, Loss_f: 5.68464e-05\n",
      "Iter 2200, Loss: 5.64339e-05, Loss_u: 7.96364e-06, Loss_f: 4.84703e-05\n",
      "Iter 2300, Loss: 5.09596e-05, Loss_u: 8.13871e-06, Loss_f: 4.28209e-05\n",
      "Iter 2400, Loss: 4.57729e-05, Loss_u: 8.56720e-06, Loss_f: 3.72057e-05\n",
      "Iter 2500, Loss: 4.19452e-05, Loss_u: 7.91883e-06, Loss_f: 3.40263e-05\n",
      "Iter 2600, Loss: 3.88559e-05, Loss_u: 7.89967e-06, Loss_f: 3.09563e-05\n",
      "Iter 2700, Loss: 3.59806e-05, Loss_u: 7.59971e-06, Loss_f: 2.83808e-05\n",
      "Iter 2800, Loss: 3.37644e-05, Loss_u: 7.75267e-06, Loss_f: 2.60117e-05\n",
      "Iter 2900, Loss: 3.11202e-05, Loss_u: 7.35131e-06, Loss_f: 2.37689e-05\n",
      "Iter 3000, Loss: 2.85292e-05, Loss_u: 7.07173e-06, Loss_f: 2.14575e-05\n",
      "Iter 3100, Loss: 2.64167e-05, Loss_u: 6.38821e-06, Loss_f: 2.00285e-05\n",
      "Iter 3200, Loss: 2.46790e-05, Loss_u: 5.78858e-06, Loss_f: 1.88904e-05\n",
      "Iter 3300, Loss: 2.33238e-05, Loss_u: 5.56899e-06, Loss_f: 1.77548e-05\n",
      "Iter 3400, Loss: 2.19923e-05, Loss_u: 5.36688e-06, Loss_f: 1.66254e-05\n",
      "Iter 3500, Loss: 2.08859e-05, Loss_u: 4.96937e-06, Loss_f: 1.59165e-05\n",
      "Iter 3600, Loss: 1.97511e-05, Loss_u: 4.81952e-06, Loss_f: 1.49316e-05\n",
      "Iter 3700, Loss: 1.86838e-05, Loss_u: 4.33411e-06, Loss_f: 1.43496e-05\n",
      "Iter 3800, Loss: 1.75947e-05, Loss_u: 3.80083e-06, Loss_f: 1.37939e-05\n",
      "Iter 3900, Loss: 1.67698e-05, Loss_u: 3.51220e-06, Loss_f: 1.32576e-05\n",
      "Iter 4000, Loss: 1.59104e-05, Loss_u: 3.32920e-06, Loss_f: 1.25812e-05\n",
      "Iter 4100, Loss: 1.48611e-05, Loss_u: 2.92079e-06, Loss_f: 1.19403e-05\n",
      "Iter 4200, Loss: 1.39493e-05, Loss_u: 2.59045e-06, Loss_f: 1.13588e-05\n",
      "Iter 4300, Loss: 1.30862e-05, Loss_u: 2.38816e-06, Loss_f: 1.06980e-05\n",
      "Iter 4400, Loss: 1.24863e-05, Loss_u: 2.22364e-06, Loss_f: 1.02626e-05\n",
      "Iter 4500, Loss: 1.17251e-05, Loss_u: 1.88465e-06, Loss_f: 9.84049e-06\n",
      "Iter 4600, Loss: 1.11779e-05, Loss_u: 1.74984e-06, Loss_f: 9.42807e-06\n",
      "Iter 4700, Loss: 1.07752e-05, Loss_u: 1.66498e-06, Loss_f: 9.11020e-06\n",
      "Iter 4800, Loss: 1.02536e-05, Loss_u: 1.55931e-06, Loss_f: 8.69431e-06\n",
      "Iter 4900, Loss: 9.83202e-06, Loss_u: 1.46909e-06, Loss_f: 8.36293e-06\n",
      "Iter 5000, Loss: 1.01618e-05, Loss_u: 1.50311e-06, Loss_f: 8.65866e-06\n",
      "Iter 5100, Loss: 8.80203e-06, Loss_u: 1.34283e-06, Loss_f: 7.45921e-06\n",
      "Iter 5200, Loss: 8.15991e-06, Loss_u: 1.24995e-06, Loss_f: 6.90996e-06\n",
      "Iter 5300, Loss: 7.66543e-06, Loss_u: 1.21400e-06, Loss_f: 6.45143e-06\n",
      "Iter 5400, Loss: 7.26559e-06, Loss_u: 1.11603e-06, Loss_f: 6.14955e-06\n",
      "Iter 5500, Loss: 6.91699e-06, Loss_u: 1.02489e-06, Loss_f: 5.89211e-06\n",
      "Iter 5600, Loss: 6.64523e-06, Loss_u: 1.00625e-06, Loss_f: 5.63898e-06\n",
      "Iter 5700, Loss: 6.36754e-06, Loss_u: 9.88469e-07, Loss_f: 5.37907e-06\n",
      "Iter 5800, Loss: 6.06887e-06, Loss_u: 9.66683e-07, Loss_f: 5.10219e-06\n",
      "Iter 5900, Loss: 5.77199e-06, Loss_u: 9.04973e-07, Loss_f: 4.86702e-06\n",
      "Iter 6000, Loss: 5.58527e-06, Loss_u: 8.44357e-07, Loss_f: 4.74091e-06\n",
      "Iter 6100, Loss: 5.41825e-06, Loss_u: 8.05439e-07, Loss_f: 4.61281e-06\n",
      "Iter 6200, Loss: 5.25042e-06, Loss_u: 8.24741e-07, Loss_f: 4.42568e-06\n",
      "Iter 6300, Loss: 5.04702e-06, Loss_u: 8.43063e-07, Loss_f: 4.20396e-06\n",
      "Iter 6400, Loss: 4.83572e-06, Loss_u: 8.11513e-07, Loss_f: 4.02421e-06\n",
      "Iter 6500, Loss: 4.71027e-06, Loss_u: 7.99702e-07, Loss_f: 3.91057e-06\n",
      "Iter 6600, Loss: 4.56763e-06, Loss_u: 8.08659e-07, Loss_f: 3.75897e-06\n",
      "Iter 6700, Loss: 4.42448e-06, Loss_u: 7.88082e-07, Loss_f: 3.63639e-06\n",
      "Iter 6800, Loss: 4.30901e-06, Loss_u: 7.49946e-07, Loss_f: 3.55906e-06\n",
      "Iter 6900, Loss: 4.18579e-06, Loss_u: 7.09653e-07, Loss_f: 3.47614e-06\n",
      "Wall time: 6min 3s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "               \n",
    "model.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error u: 1.350107e-02\n"
     ]
    }
   ],
   "source": [
    "u_pred, f_pred = model.predict(X_star)\n",
    "\n",
    "error_u = np.linalg.norm(u_star-u_pred,2)/np.linalg.norm(u_star,2)\n",
    "print('Error u: %e' % (error_u))                     \n",
    "\n",
    "U_pred = griddata(X_star, u_pred.flatten(), (X, T), method='cubic')\n",
    "Error = np.abs(Exact - U_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\" The aesthetic setting has changed. \"\"\"\n",
    "\n",
    "####### Row 0: u(t,x) ##################    \n",
    "\n",
    "fig = plt.figure(figsize=(9, 5))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "h = ax.imshow(U_pred.T, interpolation='nearest', cmap='rainbow', \n",
    "              extent=[t.min(), t.max(), x.min(), x.max()], \n",
    "              origin='lower', aspect='auto')\n",
    "divider = make_axes_locatable(ax)\n",
    "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.10)\n",
    "cbar = fig.colorbar(h, cax=cax)\n",
    "cbar.ax.tick_params(labelsize=15) \n",
    "\n",
    "ax.plot(\n",
    "    X_u_train[:,1], \n",
    "    X_u_train[:,0], \n",
    "    'kx', label = 'Data (%d points)' % (u_train.shape[0]), \n",
    "    markersize = 4,  # marker size doubled\n",
    "    clip_on = False,\n",
    "    alpha=1.0\n",
    ")\n",
    "\n",
    "line = np.linspace(x.min(), x.max(), 2)[:,None]\n",
    "ax.plot(t[25]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "ax.plot(t[50]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "ax.plot(t[75]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "\n",
    "ax.set_xlabel('$t$', size=20)\n",
    "ax.set_ylabel('$x$', size=20)\n",
    "ax.legend(\n",
    "    loc='upper center', \n",
    "    bbox_to_anchor=(0.9, -0.05), \n",
    "    ncol=5, \n",
    "    frameon=False, \n",
    "    prop={'size': 15}\n",
    ")\n",
    "ax.set_title('$u(t,x)$', fontsize = 20) # font size doubled\n",
    "ax.tick_params(labelsize=15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEFCAYAAAD+EEaoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABgvElEQVR4nO3ddZhU5fvH8fe9AcvS3UiDiAIKSIdggIqAhV3Y3a2oXzt/BnYX2I0KKCAgqQLSJd1dm/P8/phZXdeFrZk5E5/Xdc217Jk553zYuHfuE89jzjlERERERESk5BK8DiAiIiIiIhIr1GCJiIiIiIgEiRosERERERGRIFGDJSIiIiIiEiRqsERERERERIJEDZaIiIiIiEiQqMESEREREREJEjVY8jcza25mw8ysVIi238rMxprZXjNba2b3m1niAV5/qpl9ZWZrzGy3mc00szPyed35ZubyeVwWiv+HiESOSKtbgXUKXZOKs30RiX6RVrvMbNx+6pYzs865Xqf3XIWQ5HUAiSj9gCucc8OCvWEzqwyMAeYBJwFNgCfxN/l37We1G4DlwPXAZqA/8IGZVXPOPZfP648C9uX6fFlw0otIBIu0upXbAWtSELYvItEr0mrXFUCFPMvuB9oB0/N5vd5zHYAaLMntMODPEG37MqAMMNg5txMYbWYVgGFm9lhgWV4nOuc25/r8JzOrg7/xyq/Bmu6c2x305CISySKtbuVWUE0q6fZFJHpFVO1yzs3L/XngzFp7YKRzLiuffeg91wHoEkEBwMw2ARcCvXOd7j0qiLvoB/yQ55d6BP4C0DO/FfI0Vzl+B2oEMZeIRKlIrFsRtn0RiUBRUruOAyoDHwYxV9xQgyWYmQEnAmnAg0DnwGNy7teYWVJBjwPspiWwIPcC59xKYG/gucLqgv+Ud36WmlmWmS00s0uLsE0RiTJRUrcKqknBqosiEiWipHYBDAHWAL/s53m95zoAXSIoOOecma0HUoBvnHNT8nnZecCbhdic7Wd5ZWB7Psu3BZ4reMNmffBfS3xhnqfWAXcD04BE4AzgJTNLdc49XZhti0h0ifC6VdiaVOK6KCLRJcJrl3+jZqn4m8BXnHMuz9N6z1UIarAkx2GAY//XA38NdCjhPvL+koK/OOS3/N8vMmsIfAB86Zx7618bde4H4Idci0aZWWngLjP7P+ecr9iJRSSSRWTdKmJNKnZdFJGoFZG1K5cTgXLkc3mg3nMVjhosyXEYsOwANyxuBXaUYPvbgEr5LK9I/kdZ/mZmVYBRwErg7ELu7xPgNKAhGtlGJFZFbN3KR341KZjbF5HoEem1awiwxDk3o5D703uuPHQPluQ4DJh1gOfPAzIL8difBeS57tfM6gNlyXOdcJ7XpALfAKWA451zewr6j+Sho8AisSsi61YBctekUGxfRCJfxNYuM6uIf5CM4gxuofdcATqDJTla4j8lvT8lPV09CrjZzMo753YFlp2Ofw6F8fmtELiB82OgGdDVObexCPs7Gf/cWSuKH1lEIlzE1a0DyK8mBXP7IhI9Irl2DQJKU7QGS++58rD/3rsm8cjMJuI/8nAnkAFMzefGxpJsvzL+0f/+BB4FGgNPAc845+4KvOZc4A2giXNuhZm9AlwMXIv/ZsrcfnfOpQfW+zTw/Gz8N1yejv9Swmv2MyGxiMSASKxbgWWFqkmF2b6IxJ5IrV2B5d8DtZxzbfezbb3nKgSdwZIctwEvA2OBLc65WsHcuHNuW2AUwOfxH5nZDjwNDMv1sgT8v6w5o+IcE/j4f/lsshHwV+DfC/GPLFg/sO484Fzn3LtB+w+ISCSKxLoFhaxJhdy+iMSeiKxdZlYN6IN/lMD90XuuQtAZLBERERERkSDRIBciIiIiIiJBogZLREREREQkSNRgiYiIiIiIBIkaLBERERERkSBRgyUiIiIiIhIkGqa9EKpVq+YaNmzodQyRfM2cOXOzc6661zkksqhuSSRT3ZL8qG5JJCtK3VKDVQgNGzZkxowZXscQyZeZaeZ0+Q/VLYlkqluSH9UtiWRFqVtRd4mgmTU1s5fNbJaZZZvZuEKuV9HM3jSzbWa2w8zeN7OqIY4rIqK6JSJRR3VLpPii8QzWIUB/YApQqgjrjQRaAEMBH/Ao8AXQPcj5RETyUt0SkWijuiVSTNHYYH3tnPsSwMw+AaoVtIKZdQaOBXo65yYElq0BpppZX+fcmFAGFpG4p7olItFGdUukmKLuEkHnnK8Yq/UDNuT8sge2Mw1YHnhORCRkVLdEJNqobokUX9Q1WMXUEliQz/L5gedERCKN6paIRBvVLRGi8xLB4qgMbM9n+TagcXijRL6sLBg/HmZ/t5oen1xDYlY6+6rVI7lXN1rfPYiUauW8jigSD1S3RCTaqG6JED8NFoDLZ5ntZzlmdglwCUCDBg1CGCtybFuyhU/um8s9Y3qwfj2UpRK7+dz/5Fpg9itse64yk097hF7vX0xConmaVyQOqG6F2eLFMGIE/PQTPPxLN1z5CtT++QMatq3kdTSRaKG6JXEvXi4R3AZUymd5JfI/0oJz7hXnXHvnXPvq1WN7LsTsTB9jB79AQrPGDHpvMLvW76ZZM7j0hnL8eOWX/HTtl3x/zFPMTj2Sym4bR428lLH1z2fXlgyvo4vEMtWtMPr9uYmMqX02hzXfxz33wLhx4LKz6bx9FAuuf8nreCLRQnVLhPg5g7WA/IcHbYl/6NC4tXzCKnaecAZ9dk0CYGbVo/n55a20H1wOM4ABf7/W+a5j+k0jaPX0UOqsm8GQvpv5aGIdypb1JrtIjFPdCoMFXy5k10XX0WHL9wBcnNyNXWddxoABkPXKifD9FBKXLvY4pUjUUN0SIX7OYI0CaplZt5wFZtYe//XAozxL5bFpD46mQq92tNk1ifUJtZl5x6ccsflHOpzcINBc/ZslGB2eOoOt3/zKGQ0m890fdbjgAnD5nvQXkRJS3QqhvVvT+PnI22gysDUdtnzPDiowoefdPDB3MG++CYMGQYOBhwOQunmFx2lFoobqlghReAbLzFLxT3wHUBeoYGanBD7/zjm318yWAOOdcxcBOOd+NbMfgHfM7Cb+mfhuYjzOyeAcjD75Jfp+fgUJOH6vcQyNJ7/PEU0KnOICgPrHH8bI7+HII+Hjj+G4Hnu58KrUEKcWiV6qW5Flzju/U3roOfTOnIsPY3KrobT89EF6tKzxr9fV6XwQADX3/cXevZCqMidxRHVLpPiirsECagAf51mW83kj4C/8/6/EPK8ZAjwNvIH/zN03wDUhSxmhnINbboHfP29KT5KZ2vNWuo2+l4TkvF+uAzv4YHjjqe3svfgaWly3lA2nTKRmLQ16IbIfqlsRwOeDxx6DJXf+wWu+ufxVqjl7hr9Nl4s65fv65Kb+BqsBK9m2w0dqarxc9CECqG6JFFvUNVjOub/wj0ZzoNc0zGfZduCCwCMuZWfDFVfAK69AcnJfRj+zmBOuKP6IPSefYmy78keqZGzg5Qu+5NJRA4MXViSGqG55b8tmxxlnGqNHA5zPsX0zGfDR2ZSufIDTUqmpbLdKVHLbyd60FWoX7iy/SCxQ3RIpPh2OixPO5xh7+M0sfWUMKSnwxReUqLkCsEoVSb/pLgC6/3Anq1dkByGpiEhwLfnkDzbUbcfK0QuoXh2+/dY4dfQlB26uAp6o/CDX8TQZSbo+UERECkcNVjxwjl8638Ixs5/gE07hx4+2079/wasVRu17L2FTagNauXl8d7XuXxWRyDL1ji+pfWpXWmXM4ukqD/DbbxSp/o2scgX/x3VqsEREpNDUYMWBcSc8QY9pT5BJEovufpfuJ1YK3sZLlSLjUv+l1c1G/R/79gVv0yIixeV8jjEnPEOHhwdRlr1MaHQuvZa8Tr16RdtOcrL/Y2Zm8DOKiIRCdpaGd/aaGqwYN/7qj+n13S0ATL3qPTref2LQ91H37gvZl5BK76wxjHluftC3LyJSFNnpWfzS9mr6fns9CTgmHPs/ui95izKVU4q8rT77vuFs3iV7284QJBURCZ4109cypfqJ7EmuyIc9NUG6l9RgxbA5L0/myOfPAWDigMfo9tzpodlR5cr81eUsfBiLX58Qmn2IiBRC2j7HtCZn0GPOC6RRminXfUiP7+/EEoo3yumN627iXc7F1q8LclIRkeCZdO1IUju2ptPmb6jALnr9cr/mKfWQGqwYtXL+HmpePpgU0vml9WV0++KmkO6v7vA7aZq8kpsWX8rGjSHdlYhIvnbsgH79jVfX9GOrVWHes2Pp9PSQEm0zO8E/2G5WWlYwIoqIBFV6Olx9aQaVnr2fymzj9xrHAFDTrWfdSl3b7BU1WDFo9244cUhZTnMjGF37XDpPfw4stHNUVTj0IFr0qYdz8M03Id2ViMh/bNro6NkTxo2D72tfyLrxizn86q4l3q4v0GBlp6vBEpHIsnw5dO0Kz79SijOTP2H8mS/Rdt33bEquTQKOFVPXex0xbqnBijHOwUUXwezZsL5FL9rPfZuklPBMdzZwIIDjp482h2V/IiIAG/9Yy4pGPfHNmk2zZjB5MhzSvUpQtq0GS0Qi0dS7v+GHltcyc6ajUSN449eD6fn+pViCMengi3mY21iyspTXMeNW1E00LAf209lvsOOjOpQvfxxffgmVK4dv3wMPW8Zx9CbtxzLs3buAVI1qLCIhtm7GGtK69KZ95mJeSb2ehhPGUqtW8LbvEhIBNVgiEhky92Uxofc99Jn6MEcCmzody1Xf9f/X+71px9/Hw7PhgTTPYsY9ncGKIfNe/5XuH1zGd/Tno/vm0aJFePdfs0MDqiTuoIVbyB+fLQvvzkUk7qyZ5m+uGmUuZn5KO5rOHBnU5gr+OYPly1CDJSLe2jx/E3PqHEOfqQ+TTQIT+j/CXROP+8/B9FKBE1eaXsI7arBixNYlW6l06WmUIpMJba/huOtbhT9EUhJLG/tvrtz2gSYdFpHQWTF5Deld/c3VgjLtqDlnDNVaVgv6fpwuERSRCLBg5CzSDu3A4dt/ZmNCTeY9O5Ye396KJf73rXz13cs5irGU27DUg6QCarBigi/bMb/7xdTJXs2ccp3oMvFx77Ic2w+AStN+9CyDiMS21dPWkt2zN42zFrMwtS21546hStPg3HOV16M9vyOVPaxr2j0k2xcRKciY+yZRf0gX6mWv4M+yHcmeOpNDr+6139e3nfU2Y+lLm9nvhi+k/IsarBgw7qxX6br+M3ZaBaqM+oBSZZM9y9LwvJ4ANN8ymfQ0TcAgIsG1Zg08OmASDbOWsCi1LXXmjqFio9A0VwC+MmXZRyqZ2fpzKSLhlZ0Nt94KA4e1YSlNmNzkHJquHk/t9nUPuJ4l+8+8u0ydefeK/mJEucVfzafTyOsAWHjdS9Tt1sjTPFWOaMTmpJpUZzNzPl/iaRYRiS0bNkDfvvD8hlO5pdEn1JwzhvINq4Z0n8mB41W6l0FEwmnbyl0M7rePxx6DtMRy/PrIBDovepuUSikFrmulAmPYZalweUUNVhRLT4cHbtjGdioxuem5dHjqDK8jgRkr63UBYOs3kz0OIyKxYuvSbVzSfT4LFsChh8Lt0wdTsXFomyuAU/+4kwl0p9q8CSHfl4gIwOLvl7KpWWdOGX0JVas4Ro+GS2+thCUUbk5TCxwZsiydwfKKGqwodtdd8O7SLpzUcDaHTXje6zh/W37qrfRgPB9zqtdRRCQGbF+9m9Vt+vPG4m4MbjiTMWOgauh7KwDq7JhPdyaSvH1TeHYoInFtxqNjqdavA80z5tK19Ax+G7uN3r2Lto2EwBkspwbLM2qwotS4Uft48klITITnPqxGudrlvY70t3onH8kv9GDqHE2EJSIls3tzGosPGchhe6aQllSOFz6qQY0a4du/SwoM056ZHb6dikhcGnfWK7S97Vgqs40ZtU6g1l9TadC26PeY5tyDlaBLBD2jBisKbVu5i4YntuZhdyvDbk+nUyevE/3boYdCQgLMmwf79nmdRkSiVcaeTGa3GkKHnWPZmFATGzOGWh3qhzdEoubBEpHQys7I5qcjbqLXB5eSRDbjO9/K4au+JLVWhWJtL+Hve7BUt7yiBisK/XH0zTTMXsZJZcdw2x2R9y1MTYUHajzHp9knseSbBV7HEZEo5MvyMfWQC+my6Uu2WWX2fTmaOj2bhT1HzhksjcYlIqGwaxe81fYZjvrtSTJJYtJFb9Bz8iMkJBX//d36nqfTjEW83fzBICaVooi8d+dyQNMeHE3vRS+TQTKlP3iLpDLeDcl+IEcnj+MkvmLjqJleRxGRKOMc/HL4tXRf8R67KcuGN0dx0AmHehNGDZaIhMjKldC1K1w9/3LGJh/LvKd/pOtrF5R4u1a5EktoxpaE6kFIKcWhBiuK7Fi1k7r3XgTAlOOG0WiAR284CiGzRWsA3Ow5HicRkWhz//3wxpz27KYsi5/8mpbnHeldGDVYIhICcz6YQ88Oe5kzB+o3T+Wged/T5roijmaxH6VK+T9mZARlc1IMarCiyOyjb6Ru9irmpbany+e3eB3ngJIP9zd/5Vf+6XESEYkmw4fDsGHwXsJ5jH9jGe1uCM4bjuJaf1An3uMsNpZv4mkOEYkdk275ksZndeKJjefQp7ePKVOgadPgbb/K4ql8yBBOXv5E8DYqRaIGK0r89vAPdF/4GumUotSHb5OUkuR1pAOq2svfYNXbqjNYIlI4E276ileunAXAyy/D8ReEcbjA/VjQ5ULO4T3m1+njdRQRiXLO5/j5hCfp/PggyrKX2s3KMerrLCpXDu5+UrevZQgjOWT7xOBuWAotst+lCwC7d8Nlww/jbk6g7DHdOGpAK68jFahezyakUZq62StJ27iTlBrFGwlHROLD9Ccn0PHJ0xhPaT64ZRZDhzb0OhIAgfk6ydRoxyJSAtnpWfx6xFX0nvsyABOOe5Du395e6MmDiyIxxV+4ErJ1abNXdAYrCtx2G0xfXZt7235F969u9jpOoZRKTWJlKf/57tXjl3qcRkQi2fyP5tDspgGkkM6fbc7msocP8jrS38qnb6Yl8ym9UxMNi0jx7N24m98OGki3uS+zjxQmXzuSHqPuCElzBZBYOjAPlk8NlleirsEys1ZmNtbM9prZWjO738wSC1inoZm5fB4jwpW7uGZ8vY4XX8gmKQnefMtILh0937I/6/XjQ4awbE0pr6OIeCre6lZRrJ68kopn9KMSO5hWfzCdpz8bsjcdxdH256eYTyu6zH3V6ygiYafaVXKbNsEHhz9Ohw3fssWqsvCFsXR55rSQ7vOfBkun3r0SVZcImlllYAwwDzgJaAI8ib9RvKsQm7gJmJTr883BzhhMmXszKXdaPyZTmnGXfEybNg28jlQkkwY+zlNPwUP74Bivw4h4JN7qVlFsX7aV9N7H0cS3hlkVe9BmzvskJB/wvVvYWbIm7JT4pNpVckuWQL9+sHLNHVQou5LDP7qdtv2bh3y/f18iqDNYnomqBgu4DCgDDHbO7QRGm1kFYJiZPRZYdiALnXNTQp4ySCae8jS902axMqkR19xX1es4Rdaihf/jwoXe5hDxWFzVrcJK3+djZbuTOCxjPotKt6bhrC8pXTHF61j/oQZL4phqVwnMeXMGJ97ckhVbytGuXWm6f/smtWuHZ985A6ElqsHyTPRcb+bXD/ghzy/1CPwFoKc3kUJj5c9LOXLUMAA23fciZaqV9TZQMTRpmE19VpIwZ5bXUUS8FDd1q7B8Pjj/wgQe3nkFyxObUHb8KCoeVMnrWPlKUIMl8Uu1q5im3fopzS7sxotbTuX4YzIZP56wNVcAidUq8zO9mJV4ePh2Kv8SbQ1WS2BB7gXOuZXA3sBzBXnTzLLNbJ2ZPWVmZUIRsqScz7Hp1MtJZR8TG57FEXcc63WkYmnqFrOSgxg2e5DXUUS8FBd1qyhuvx1GjIBvy5/BzslzqXtkPa8j7ZdL0s3iErdUu4rhl1Ofpf1jp5JCOmVaHsTnXxjly4c3gx3SiqP4mVvKPBfeHcvfou0SwcrA9nyWbws8tz/pwAvAj8BOoBdwK/7riU8KasIgmHrN+3TaMpqtVoXmXz/ldZxiq3lkQ3wYdbJWkp2W+fc1wSJxJi7qVmH9dPYbjH3/MJKS2vPpp9CmY2mvIx1YYqDBcmqwJO6odhWBL8vHxM4302OG/33bT30fovcPt3kyaE+pwNhiml7CO9HWYAG4fJbZfpb7V3BuHXBVrkXjzGwDMNzM2jrn/vjPBs0uAS4BaNAgfINL7Fi+lWbDrwdg9nlP0qu19xNtFldKpRTWJNSlrm8162auonbXxl5HEvFKTNetwppy1zf0fP9ixpPCt48t4uij63odqWBJ/kE3dAZL4lTIa1ek163CyNiZxm+HnkePlR+RSRJTLn6Do145x7M8yYk+KrCLlHQHVPIsRzyLtksEt5H/T0pF8j/KciCfBD7me4Gqc+4V51x751z76tWrF3HTxXfnoxW4393FhCon0eO188K231BZX7YJAFtnLPM4iYhnYr5uFcaf7/xG6weHkIiPGb1u5rTro6C5AjZ0PZkejOfLg671OopIuIWldkVy3SqM3bvhnQ7P0mnlR+ygArMe+Z7uHjZXAMkrl7KDSvyS0dHTHPEs2s5gLSDPdb9mVh8oS57rhAvB5fnouSlTYPgrSSQmXcslE64lIbJGKy6WPZXrwy7YNX+111FEvBLTdaswVv+6imoXnEA59jC56Tn0GHuv15EKLaNGPX6hHuXi4u4RkX+J+9pVkE2b4Pjj4fdF11MmZSFt37iW9mcc5nWsv+fBSiKL7GxIjIH3k9Em2s5gjQKONbPctwueDuwDxhdxW6cEPs4MRrCSys7I5u5LNuAc3HwzHHKI14mCI6um/yh1xjI1WBK3YrZuFcbO1TvZ2/t4avnWMatSTzr8/mpETSRckITAX0mfz9scIh6I69pVkNUTlnFc5x1Mnw71GibTcfbrHBIBzRX8M71EMpm6D8sj0dZgvYT/5snPzKxv4LrdYcBTuYcRNbMlZvZ6rs+HmdmTZjY4sN79wNPAZ8652WH+P+Rr4vmv8cmc5lxf5S3uvNPrNMGT0MDfYNnaNR4nEfFMzNatgmRlOhYcfgbN0+ewrFQLGv7+OcnlInxQizwqLp3JU1xP79Xveh1FJNzitnYVZNHI3ynduzNPLB1Ih0PTmDwZmjXzOlUuSf+cwVKD5Y2oarCcc9uAPkAi8DVwH/5f2rzXmyQFXpNjAf45G94EvgPOBB4PfPTcloWbOWzE7VRkJ6edX5ay0Tfl1X6l9T+Zjkzlxdr3ex1FxBOxWrcK4/objIc3DWVlwkEkfv8dFRseaOCxyFR+9QKu5xk6bB7ldRSRsIrn2nUgs575mVpDelLdt5HylZIYPSorrHNcFUquBisjw+MscSra7sHCOTcPOKqA1zTM8/kI/JPjRaR5J91Od7eN36r05cjHTyl4hShSo20dplOHfeu9TiLinVisWwV57jl4/nkoVWoQN3/fny69o+vMVQ4XGKbdXLbHSUTCLx5r14FMu/VT2jx2JqXJYGK902n/59ukVIzA2pbsnxYnmUwydXmzJ6LqDFYsmvfGFLovfI0Mkqn03vNRdW9CYdQLzB+6dq23OUQkfGbe/QUfXTsJgDfeIGqbKwALDNOe6NN1NiLx7JezX6b9Y6dSmgx+bn0VnZd9EJnNFfzrDJbuH/WGGiwP+TKzsauvBGBip5to3K+Fx4mCr1o1eMau49Wtg0nfrTcoIrFu8YczaPW/Mxjt+vDs5fM56yyvE5VQoMEyF1ODn4lIITkHH57zHd3fv4wEHD/1foBes54lMTmC30KnpHBZxQ85l3fI1sl3T0TdJYKxZPL5L9Nt72+sSaxPxy9iaGSLXBIS4DT7mNpuLWvmrKNu5+icRFBECrbxj7WUP+ckypDGz40u5KrnWxa8UoSznGEEnQ4Di8Sb7Gy45hp46b1jSeQ0ap7Zh6Pev8TrWAVLSuKbckNYswOeVenyRAS337Ft61YY9m1HptOe5dc+Q7maMTSyRR5bU/wjCe6Yp5EERWLV3i372NRtILWy1/JH+e50/uPFmLjk2RL9fyZNDZZIXEnfmc6Fg7czfDgklUok6ZMR9IyG5ipAU0x4S2ewPHLXXTB2R3tu6zWVMY9H/5uQA9lZvi7snc6eRWqwRGKRL9sxs91Quu+ZzurEg6g75VNSKpTyOlZQuHLlmU9LNibX8zqKiITJjtW7WHLYIC7dtpcfyo9h5Nep9OwZXe/VLt79FHvIIDv9JvR2P/z0FffA75P28tJLqSQlwbPPJ2Axfh5xX5W6sAEylqvBEolFo/s+wrGrPmAX5Uj7+GvqtarudaSg2d2+F52YT8eGMNjrMCISchvnbmJzh34csW8mGxNqMu7dVbTsGX33yN+8/U5SSGNZ+jXo7X74xfhb+8jjy3YkHnc0H7uTufOi9RxyiNeJQs9X0z9BhFunsdpFYs3bb8P/jWvDdiqy+N73aTroUK8jBZUusxGJH6snrWB3u2602jeTFclNSB87iZYnRV9zBZCFf6h2X0aWx0nik1raMPvlyhH03D2Z2gk1OPquVK/jhEVi7RoA2KaNHicRkWCaPBkuuQQy6M+nTyznohujbyLhgljgqiA1WCKxbclX8yg76Bga+9awoExbqk77nuqta3odq9iyLAkc+NI1grMXdAYrjHau20PTV28BYMkFD1GhXgWPE4VHYvMmjKcHSxOaeR1FRIJk9W8beeT4X8jIgKuuIiabK4AKM39mD6k8u7if11FEJERmf7GMKgO7U9u3hj8q9KD2gnFR3VwB+Mw/xYTL1tEhL6jBCqNppz5OXd9qFpQ9nE4vne91nLBJOuYoejGe4RVu8zqKiATBnq3pbOoxmE+3H8U9h37O0097nSh0EsyRyj6SXbrXUUQkBH7+Gbqd3ZDvXD+m1jiB5su+p2KDil7HKjEXeIvvy9REWF5QgxUmK35ZSddJjwLge/IZLDB5ZTyoVcv/cd06b3OISMn5sh1TD7+cdnsmsTmpFteN7ExSDF9srmHaRWLXF59m068f7NqTwI9D3uTw5Z+RWrWM17GCIjtwBsuXpdrlhSL/WTSzQ4GOQC0gBdgKLAImO+e2BTde7Fh55q0cRBpTGp5Op0u7ex0nrGrVgtKkkbxuI841+PueBpFwUu0KjtH9nuLYFW+ylzKkjfiS2gfX8jpSSKnBEi+pboXOxIvepPYbL1GK0Qy9sgLPPpv896A2sWB3YkWSs/bhfM7rKHGpUA2WmTUGLgfOAmoCPmA7kA5UAlIBn5mNB14DRjqnv0Y5fh7rY9bqmrShPI0+eszrOGGXWsaxjcqUyUxj6+rdVKkfu5MqS2RR7QquX27/jqNH3wzAwjveod3Jh3ucKPTUYEm4qW6F3viBT9HzyxsBeGvAZwx67vyYO/h76iHz+e03mF7V6yTxqcBe3cxeA+YCbYH7gXZAinOuunOunnOuHFADOBGYAzwGzDezbiFLHUWys+G6GxK4nmd45c6V1OzQwOtI4WfG1iT/SILbF2kkQQkP1a7gmvfJPNo8MoQEHJOPvY92D57idaSwSEjy/5lM0PtXCQPVrdByPse4bnf93VyNG/gMg7+MveYKIDFwJ4pGQPVGYc5gpQEtnXMr9vcC59xmYBQwysxuAE4F6gYnYnR77TWYPRsOOgiuvLOS13E8syOlJnV3r2Tn4g3Qp5HXcSQ+qHYFyfr1cM8Vm3mFJKY1PI3O393tdaSw+fsMFnqXImGhuhUiviwfE9teRa+5L5JFIr9e/Aa9XjnX61ghozn8vFVgg+Wcu6ooGwycph5Z7EQxZPvKnbS76jgGcyNDHhtMmTIxeIikkPaUrQG7Yd8KncGS8FDtCo60NBg0CKZs6kHC4dN5d0xtLCF+all2vYO4nqfwVajN/3kdRmKe6lZoZO7LYvrB59JjxYekUZo/bv+I7g8N8DpWSD274GiqsZStK8dAp8Zex4k7Rbqdz8yeMYvFE6mh8dvJD9Ix61fuK/8kp8TH1TT7lVHRf4lg+io1WBJ+ql3F43yO+0+fy5QpUL8+PPddE0pXjo8J0nP4atbmGa7n67JDvI4icUZ1Kzj27oVBpyQyb0UqOynPvCe/p1OMN1cANTNW0ZjlkJHhdZS4VNTxUs4AvjCzfP/CmplmYgxY9uMSus54BoDk4f8XV0d885Nd1d9g+darwRJPqHYVw9jBL/DAV4dxXfILfPUV1IzueTeLJecyG6eBuCT8VLdKaPt2OPZY+PY7444qL/PXxzM4/IZeXscKC5+GafdUURusTkBT4Bczq52z0MyONbOpwDfBDBfNNpx7E6XJYHKz82hxdgev43gv8M4sYdMGj4NInFLtKqKp/xtNry+vIxEfZ1xZmbZtvU7kjaRd2ziL9+i1Rz8iEnaqWyWw6c8NTGp8Nn9O3EbdujB+YiKHndLc61hh48z/Ft9laaJhLxSpwXLOLQe6AJuBaWZ2oZlNxn+z5Q6gV9ATRqHpj4yl84Yv2UU5mn3ysNdxIsKO7idwEl/wRZ0rvI4icUi1q2gWf7uI5nefRhLZTOxxBx2fPtPrSJ5JXreS9ziHm7ff6XUUiTOqW8W3euJf7Dm8G8dve583y1/LpElw8MFepwqvvxusbJ3B8kKRp1Rzzu0AngAqA6/in/ius3PuGOfcL0HOF3Uy92VRcdh1APx+3B1UP6z2gVeIE6ltmvEVJzErrYXXUSROqXYVztal20gcdCKV2c60ugPp+tMDXkfylObBEi+pbhXdkq/mkdizGw0zlzC/TDu6TH6Cgw7yOlX4/X2JYKbOYHmhqINcHGtmE4HvgcnAy0Ar/KewBfjw4b9ISd/ByqRGHDnieq/jRIzq1f0fN+oWLPGAalfhZO7LYmmH02mcuYhFZQ6j9W/v/t1gxKu/58HSMO0SZqpbRTfvrWlUGdid2r41zKrQnToLfqZG6xpex/KEzmB5qzDzYOU2CvgZ6OmcmwhgZn8Ab5hZc+fcvUHOF1W2bIHrnm9KGgv45um/aFAxxetIEaNmuT3cwTNU/isDuM/rOBJ/VLsK4X8XLefKbX+wOaE65X/6itQa5byO5DmdwRIPqW4VwR9PjqXpTSdRjj1MrXECh877iNSqZbyO5Zmf6p3L5/P60L5iHI5OFAGK2mD1cs5NyL3AOfeKmS0HPjKzFs65uB3L9t57Yds26Ns3ld5XtvI6TkSpWhUe5C727U0hO2sYiUnxPaqihJ1qVwGGD4f7P2zGiFLT+GT4Rg7tFIfX1ORDZ7DEQ6pbhfTFF7Dy1m9oyx4mNjyLI+e+SXJqstexPPVt42v4Zh58WcXrJPGpqINcTNjP8tFAN6BjMEJFo8VfzafR8JupZDt4+mnQzBX/llQhlX2kUIY0tqza63UciTOqXQc24avtXHON/993vdaQQy+K6y/HvyXoDJZ4Q3WrcN56C04+Ga7LfpK3+75Dl8XvxH1zBZDovwULn0qXJ4J2cb1zbi5wZLC2tz9m1srMxprZXjNba2b3mwXu5DvwehXN7E0z22ZmO8zsfTOrGoxMzufYfuH13Oie4JPD7qN162BsNcaYsT2pGgDbl2z2OIzIP8JRuyKxbuX466dlHDywOTdlP8ItNzvOOSeYW49+CYn+o2U6gyWRJJ7fc+X24xlvcNMFm/H54K67Ezj3x3P+Pusc75ru/I2+jCZxx1avo8SloP4UOuc2BXN7eZlZZWAM4ICTgPuBGyncTT0j8Q9pOhQ4H+gAfBGMXNOGfUeHLT+wg4q0HXF7MDYZk3aX9jdYO5eG9MdEpMhCWbsitW4B7Fi1k6x+J1LdbeKU6hN46H9qIv6jcWNS2UOncnO9TiLyL/H6ngv8B7bHdbuLY0ZcxHf055knsrj/fl09lNsFc25gNMdQftksr6PEpaLeg+W1y4AywGDn3E5gtJlVAIaZ2WOBZf9hZp2BY/HfKDohsGwNMNXM+jrnxhQ3UMbuDGo84h8tcNbAe+nRsnpxNxXz9patBntgzwqdwZK4EnF1CyA7I5uFR5xJx4x5LC19MM1nfkhiqQIPTMedhKQE9pFKkvM6iUjYRWTt8mX5mNj2KnrNfZEsEkm/+GquvTHa3s6Gni/BX881iqA3gnYGy8x6mFnLYG1vP/oBP+T5pR6BvwD0LGC9DbmvZ3bOTQOWB54rtslnPk+jzMUsK9WCzu9dWZJNxbyMCv4zWOlr1WBJ5AhD7Yq4ugXwS7fb6bjpW7ZaFZJHfU2F+hVLusmYFLgFS/cxSESJ1/dcmXsymNL0LHrMfZE0SjPj9s/o/oqua86Xhmn3VDAvERwHzA1cq3t8ELebW0tgQe4FzrmVwN7Ac4VeL2B+Aesd0Ka5G2n3tf9M+dY7nyK5bKnibioupNc8iKU0ZscuHSUvrI0bwenIeaiNI7S1K6LqFsDEoW/Ra/rjZJLEyic/oUHvJiXZXExL2LKJCXRnxL6TvI4SNZyDdeu8ThHzxhFn77n2bt7LrEYD6bJiBDspz7wnv6fTQwOKu7mY5xJyGixNNFxY69YF7z1XMBus3sAJwC/ANUHcbm6Vge35LN8WeC7Y6x3QmEs/piI7mV69H+3v6V/czcSNWWc8QlOWMrbGGV5HiQoZuzM4r+N8jjkGNmzwOk1MC3Xtiqi69eu4dOq97j8w9OuZz9P2+t7F3VRcSPBl0Z2JHOGb5nWUqPHR0B9p0yqTn37yOklMi6v3XNu3w4ud3qb9plFstmqsevtnDr+hV3E2FTdczlgkOoNVKHN/XMNFh0zh5puD02QV6aJVM+sFTHbOZeR9zjk3PvDPUSWPdUD5/bdtP8uLvZ6ZXQJcAtCgQYP/PJ+eDg/vvJJ3EprxwtuaL6YwagQmU9+kMS4KZfJZL/D1ipt5Zs+DVKlyq9dxoloE1K6IqFsA02eX5lEm8mzXjzj5/UsL2L1oHqyimXbPN5z6xgCq04vd238k+m71jhwRULcgDLWrMHVrzx54LvMySpVbRf8R53LI8aG+OjL6/X0GK0tnsAoyeTIcf1odbtvxLAsmVyYzswWlSnhRWlHPYI0F2pZslyWyDaiUz/KK5H+0pKD1Ku1vPefcK8659s659tWr/3fgitKl4bff4M7xx9C4X4sDhha/nAZr4wZd81aQzQs20+6r+0gim55XtiZZU3qUlJe1K2LqFsA118D7P9dlwM/XH2DXkkMNVuEt+XIuLR84kwQcCX2OYsBgNVclFBfvuQpTt+rWhdFjjAF/PkQTNVeF4jTIRaH88F02ffvC9h3GjEEP8dL3DUvcXEEhGiwzy10h9zsAppkdaWZrSx7pgBaQ5/pdM6sPlCX/6333u17A/q4TLpSkJOjWrbhrx58Ga35lM1V5/Lc+XkeJeHNPvoeK7GBm1WN0+WkxRVDtiqi6BdCrF2raC8kSNA9WYWzZAjPPeYYK7GJy/dPp+eOdXkeKShFUtyDCalezZnCQLhgqtPe7vURjlrK6ZV+vo0SsX2/4mGonHEnKvq1ccAF8+FEipSuUDsq2C3MG604zW29mOXMhHG9mHc0sNc/rSgFBn0Quj1HAsWZWPtey04F9wPj8V/l7vVpm9nc7ZGbtgcaE/vS6BFSqW5aqbKVi+kavo0S0RZ/Mptu8l8kikYpvPP33GzwpskipXapbUUxnsAqWmQmnnQZn7XqRZ+o8Rtvf3lDdKr5IqVug2hXVdpWrzXIak55U1usoEemX816j49NDOMLN5PXe7/P66/4TJ8FSmE19gP9072H4j6bcDNwN+MxsGTAL/xGJHsCi4EXL10v4b+b8zMwexf/LOgx4Kvcwoma2BBjvnLsIwDn3q5n9ALxjZjcBPuBRYGJJ52OQwqvYxD9Me2XfZjIyCMop2FjjfI7dl1xPIj7GHXY1vQa08jpSNIuU2qW6FcUs0d9gGQ7nNJFpfm66PpuffkqkRo0kTp5yM6nVvE4U1SKlboFqV1RLDIxxoSkm/mvc8Y/T67tb/P/u8wADf7wq6LW9wAbLObcYWAxgZgOAE4H1+H/5cx4DgJ34J6ULGefcNjPrAzwPfI3/Wt6n8f/C55YE5B0LfEjgtW/gP3P3DaEbeUfykVDdf7CtGpvZuMlRp67eqeT14xurabdtDlutCod9OszrOFEtUmqX6laUK1WK9zmLPaRyke+fNy3iN+HcVxnw7ghGJn3EZ59XpX59rxNFt0ipW4Esql1RrPecZ+nNLyQsvhbQ/SzgP4g9vtsd9Pr1EQAmnPocvT66KiT7MqdJdgrUvn17N2PGDK9jxITdiRUo59vFnAnbOLR7Ja/jRJT0dDjkENi0dAevXTOHU/+vcAXRzGY659qHOJ5EGdWt4ElOhqwsyMjQvWu5zXpuAq2u6UMyWfx86Qh6v3R6oddV3ZL8qG4Fz4wWZ9J+0Yd8f/Z7HPfuWV7H8Vx2po9Jba+kx7yXyCKRqZe/TdfhRfu6FKVuBXMeLJEC7Szlv3Zkx7ItHieJPM89B0uXQp2WFRn4hI42iUSKwGjHutQml9WTVlD32pP9zdXhNxSpuRKRMEjQNYI5MjPh7HOM3+eVYh8p/HbX50VuroqqMKMInmNmRboowsyamln34seSWLU3cHH+7r82e5wksmz6cwN773qIFPbx1FM6Sh4Mql0SFD4fBzOfg5mn9ykBu9fvZk/fAVRzm5le9Vi6T3rU60gxQ3VLguXvebDifJj2vXth4EAYMdK4p9zT/PnmDDo+cGLI91uYM1g3AkvN7AEza7O/F5lZVTM7y8y+Bn4HagcrpMSOye2v5UqeZ6XThfq5LTzlTu5Jv5Mv6l1Fv35ep4kZql1ScllZ/JHRij9oqwYL8GX5+PPwc2iRNpvlyc1pNv1DklI031UQqW5JcFjgLX52/E40vGPlDn5ufCHTvttE1arw07gEOpx/SFj2XZhBLtqa2enA1fiHD90NzAc2A+n4J45rBDTAP/LNe8Blzrk1oQot0Wtl97MY/iPc/p956ePXopG/02XhG2SQTNNXbvU6TsxQ7ZKgSPhnmHY1WPD54Hc5ed0XbLdK8PXXVGpU2etIMUV1S4ImMCKPi9PCtWnuRrZ0OJbj9/3B+ylbqP/Llxx8cPj2X6jDTs65kcBIM2sK9AEOB2rhn2xuAzABmASMc85lhiirxICcSdo3aioswD+iTdql15KAY1K7q+ndr7nXkWKKapeUmP0z0XCcvk/52wcfwDlfn80jNo+jHuzDEceqXoWC6pYEQ84lgmTF3xmsNb+uJKPn0bTMXMRfyU1pNeZZ6oWxuYJCNlg5nHNLgCUhyiJxoFHWYs5jEtXnN8Y/jUd8m37rJ3Tc8QubrRptP73b6zgxS7VLiu3vM1j+ebDi1bRpcOGF4CORlP97lCOu9jpR7FPdkpLYXP1gxtCHneXqeB0lrJaPWkDpE4+mUfZqFqa0ocr0H6jeumbYcxRpFEEzG21mT5nZBWZ2hJmVCVUwiU2NV/zMW1xA58XveB3Fc+nb91HnmZsBmHPa/6jcqJK3gWKYapcUW67ZJ33Z8dlhrZ2+hg09TqVC+kYuvRSuCs20MZKH6paUxNTO13M0Y1jYPPQDOkSK+e/PpPzx3amTvZrZ5btSa8E4T5orKOIZLGAF0BW4BEjln5nF5wQefzrnPgluRIklqQf5rxEss0ejCI699CP6Z61gYenD6P72UK/jxDrVLim2bBJIxIcvy8d/51ONbXu37GNbr4GcmD6D92uUptdz7+XuOSW0VLek2BLibIyLCRPg1wu/5Fa3menVjuOQ+Z+SWi3VszxFvURwKICZGdAM/4zivYBTgePw/+XRL7vsV/lG/mHay6XFd4O1YQMM+e5c+lKeWx+qSVLp+HrTFm6qXVISvjhtsJzP8Xu7C+m6dwYrkxpxxC/PaAqJMFLdkpIo7dtHJdJISE8BYvvk51dfwemnQ1rGfVRq34ALfj6XUuVKeZqpWBMNO79FzrlPnHNXAYcAM4G+QU0nMadcQ3+DVdm3mX37PA7jobvugl27jYzjB3PkDV29jhM3VLukOE6p/BPd+AVf0aYninrjjnmIrqtGsItyZHzyNVWaV/M6UlxS3ZLi6D32LrZRhY4zhnsdJaTGXzGSKwatIy0NLrvMGDplqOfNFRSzwcrLObcZuBm4Jxjbk9hl1f1/oKuxmU2bPA7jkT9HzmXiawtISoInn/Q6TXxT7ZLCmJ7SnUl0wxecP5lR4ddbPqf32LvwYSy450OanhSeuWOkYKpbUihxcI3g+AFP0vPFIXznO5b7bk9j+PC/R6f3XFEHuehoZmX38/RioHPJI0lMq1wZH0YVtrJxXez+0u+PL9vhhl7MbA7l5RO/pkULrxPFB9UuKYmc9ynxMkz73K+WctjjZwPwy/GP0uG+EzxOFJ9Ut6REEmO3cDmfY1yX2+n59U0AbB00lHseSomo+0OLOsjFFPw3Wf6F/wbL2cCfwDrgTGBrUNNJ7ElKYndyZUpn7mb7X9vhyKpeJwqrSVd9SPfdv7IxoSanPNfL6zjxRLVLiu22nbeTzV58ex8FUryOE1Lr10P/KxtxETdyVJOV9PjqJq8jxTPVLSm+hNicaDg7I5vJh11Gr4WvkUUiUy97i14vnu11rP8oaoPVCP9Nlm0CjzOAJoABu4GLgppOYtL1g1fyxshU3kqLoEMNYbBr/R4av3IrAIvPf4iudct7nCiuqHZJsZ27ezgV2MnK9PuJ5QYrLQ0GDYKVqxP4ocv93DrWYQnxVacjjOqWFF/g1LvF0CWC6TvS+L3VWXRf+xn7SOHPez+h67DjvY6Vr6KOIrgC/7ChX+csC8zLUA1Y55zLCm48iUUV6/iveNi40eMgYTZt8MP08a1mQerhdH7pPK/jxBXVLikJZwngwGXH1pHg3JzP8XWXR1j5+7k0aFCXzz6D0ilqrrykuiUlknMzUoycwdq1C17o/BG3rf2MHVRkxQvf0OGKbl7H2q+insH6D+fcPmBVELJInKhRw/8xnga5WD56Cd1+fRwA37PPk5AcIXdhxjHVLimsnMEt/MO0x6ZxA57i1N/voJ29wZ5P51GzpsZjj0SqW1Jof988Gv1nsDZtgv79Ycb8cyhVdgknvHkyh53axutYBxQ/QyJJxOj92xP8QRsaTfnQ6yhhs/acWylNBpOankeri3Rfskg0cYE/lbF6BmvqPd/S89ubAdhy0yO0aa/mSiTaLT/iFE5jJDMbn+Z1lBJZ8+tKTuu0khkzoHFj46RZ99M8wpsrUIMlHqiavYk2zCZlwwqvo4TFt9/C2Rue4KOkM2n+2SNexxGRIvJZ7J7BWjByFq0eGEICjvFH3ceRj53sdSQRCYId9Q7hY05jdaXWXkcptqXfzMe6d+XFZcfQs9UmJk6EJk28TlU4arAk7ErV8c+Flbxjs8dJQi89Ha67Dv6iEWsee5/qh9byOpKIFFGsnsFa//s6Kpx1AuXZzeSGZ9Jj9N1eRxKRIIn2abDmvjmNSgO6Uyd7NekVqvPld8nUru11qsJTgyVhl1Lf32Cl7I79m7Deu+1Pli7xcfDBcNVVXqcRkeJYUboZ8ziYbBc7fzL3bEljS7cB1MlezZzyXTjij9c1YqBIDKm5Yhq38CjNV//kdZQi++2xMRx04VFUdVuYVuN4mi39gYoHVfI6VpHEzl8LiRrlG/tHuaiwbwPOeRwmhNZPX8WQZ45kEl157pE9JOu2BpGodEHjCRzCPDKr1PQ6SlD4fHD2RaV5d+/JrEhqQp1pX1C6YuwOPy8Sj2ov+YVHuY3DVn3rdZQi+fXGT2h9a3/KsYeJjc6m3fLPSa2W6nWsIlODJWGX0rgOALV9a9i92+MwIbT81Jspy15cnXr0GVDW6zgiUkwWOLETI6Mdc/vt8MWXxksVbyNt2myqtqzudSQRCbYoHEXw47tnc+RTp1GKTMa3vZYui94mOTU6j06rwZKws3p1AajD2pgdqv2PZ8bRecVI9lKGuiOf9DqOiJRAzvuUWDjjPuaKzxj52F8kJcGnn0KLdtF3ZFhECmaJgYmGo+DIkHNw331w2v8O43FuZlyfB+gx82kSkqK3TYne5BK9qlXjy2oXMpwr2LghBt6x5JG5L4vU264GYGrv2zmoWwOPE4lISXyysDV7KUPSymVeRymR358eR88XT2cqR/LGo5vo08frRCISMlEy0XB2Rja3nruOYcP8B7MqvfgIvcbcFfX3hJZ4omGRIktI4LVOr/PNN3DIOq/DBN+EIcPpk/4nK5Ma0/mzm72OIyIlVNqlUYa0qB5FcNn3i2h442CSyWLBEWdzzg26LFAklv1zBityLxHct3Ufs1qfyWXrZvFR6ck8M6IWAwdGd2OVI+rOYJnZxWa22MzSzGymmRV4DM7MhpmZy+dxXDgyy381CJzUWbnS2xzBtmbGOjp8dRcAm+98mpRKunFcVLeiXbQP07518RYSBhxPZbeNqbUG0G3yY15Hkiih2hXFkiL7DNa2ZdtY1OgYOq37giq2jS+eXcnAgV6nCp6oOoNlZkOAl4BhwETgAuAbM+vgnPuzgNV3AHl/uecHPaQUSusKK+nLQnbPaQo08jpO0Fz/YDXqcy+D6s+k27ABXseRCKC6Ff2ieaLh9F0ZrOhwMu0yl7CgTFsO+f19Eksleh1LooBqV3SzlBS2U5F0i7wDvWunrmJPz360SZ/L2sR67P30e9qedIjXsYIqqhos4D7gbefcAwBmNh5oB9wGnF3AulnOuSkhzieFdNQfT3I5z/LW9CeBG7yOExSjRsHHXyRTtuyNXD/Z6zQSQVS3opyz6DyD5XyOae0upfuO8axLqEPF8V9TrlY5r2NJ9FDtimLrjz2PI549j+NawIleh8llyZdzST35OJplr2ZJ6Vakjv+epkfW9zpW0EXNJYJm1hhoDnyUs8w55wM+Bvp5lUuKJ6WRf6j2pI1rPU4SHGnb0xh2+QYAhg2DevW8zSORQXUrNkRrg3Xf/cZHSw9nF+XY/vZX1O6gwiSFo9oV/XLm3szM9DZHbtO+3kDVQd2pk72aWRW6UXXeROrEYHMFUdRgAS0DHxfkWT4fqGJmBd2xW8nMNptZppn9bmaDgx9RCqt8C3+DVXb7Go+TBMfUgQ/zw4oWXF/vY6691us0EkFUt2JANN6D9eab/mGPhydczaR3lnHw2Ud4HUmii2pXlCtVyv8xI8PbHDm++AJ6nlaTZ93VTK11Es2X/0jlxpW9jhUy0dRg5XwXtudZvi3P8/lZAtwCnAacDKwFPtUvvHcqtvLPhVU1fQ379nkcpoRW/LiQTuMfoRI7OO+22n8fNRJBdSsmjKh/M9fyDGmVa3sdpVCmP/YzT1y8EIDnnoPjztGIgVJkql1RrsaUr1hKY65c7P1R3zf/bwcnnwxpabDukmG0X/EpZaqU8TpWSHl6D5aZVQQK/IvlnMt9BCXvxEm2n+W5138vz36/BiYD9wCf7SfbJcAlAA0aaB6jYEus7z+DVY/VrFoFzZt7HKiYnM+x9YwrOIgMxje9kJ5XdvM6koSY6lb8GVP7HMYthIEVvU5SsAUjZ9Hi1pOYQDKvXTyNK65o4nUkiRCRWrtUt0KjVNZeGrOcJekbPMvgfI7xfe6n77jXqMNkLr6vPnffbZjF/kA7Xg9ycSrwaiFeZ/xz1KQS/tFpyPU5/Pcoy34555yZfQY8amaJzrn/TBLgnHsFeAWgffv2sTcbrtcaNsSH0YCVjF+WSfPm0XnaZ/LVH9J1609ssaoc/OWjXseR8FDdijMJgWs9InS047+tnbqKimf2pwK7mNxgCDcPj50RWiUoIrJ2qW6FRmJyoHBlezMPVubeTH49/Ap6LXyNbBJ4c+hk+t5zuidZvODpJYLOudecc1bQI/DynCMqLfNspiWw1Tm3qTgRih1eSiYlha1l65NENlt+W+F1mmLZsngrzV68HoB55z1GjVbVPE4k4aC6FX+O3DqKc3iHhK2bvY6yXztWbGd3z/7U9q3lj4o9OGLOWyQkRdNdABJqql3xJbG0/xxKgi8r7PveuXonsxqcSI+Fr7GXMsy4/TP6vho/zRVE0T1YzrllwCL8R2AAMLOEwOejirItMzNgEDArv6PAEh7vnTeGimxn1p6mXkcplrn9bqKG28jsit3p9tr5XseRCKS6FRvOXT6MdziPUquWeh0lXxm7M1jWdjDN0/9kaamWNPztc0pXKO11LIliql3RL7GMf5SLRF94R7lYN2MN65r1oP2WH9hk1Vn22s8c+dBJYc0QCby+RLCohgHvmdlfwCTgPKAZcGbOC8ysJzAW6OOcGx9YNh74FP8RmbLAxUAnYGD4okte1To3Y+dwWLTI6yRFN3o03LH0cl6wudT46DUsMWqOVUj4DUN1K7oFrhHMzoy8awSdzzHtsKF02/4zGxJqUXrsKCo1ruJ1LIkNw1DtilqJqf6DLEnZ4Wuw5k7ZRcVuXWiRvZLlyc1I+H4UrY+Kz/tAo6rBcs59aGblgFuBu4G5wAl5ZhQ3IJF/bsQE/4g21+G/udMH/AYc75wr0lEYCa4WLfwfFy70NkdR7d0Ll14Ky+nATw9O4bZjrOCVJG6pbsUAi9wG6667jQ3Le9Car9j6zjcc3K2h15EkRqh2RbecBivZlx6W/Y0ZAyefXJ7Lsy/nzPJfU2/Gl1RpHr+3TkRVgwXgnHuVA9yk6Zwbx79/0XHOXRTiWFIMLbP+5DtuZv28uvh8r/19I3mke+Gq+SxffjBt2sCNN6m5koKpbkW5CD2D9eyz8NBDkJg4lNPeP5ljTo/dOWXEG6pd0SuhYQMe5ybWJzehU4j39cEL2zjvuspkZcHyU2+l+Ws3kFKhVIj3Gtmi5C2txKLylRLpx/f0yP6ZVau8TlM4C96ewg1vtuYdzuXVV5zmvBKJBxHYYP1y7Se8du1sAF5/HTVXIvIviU0acguP82riZSHbh/M5fu59P0dddTD1spZz883w4QiL++YKovAMlsSQxo3JJoGG/MVPf2Zw0EGR/QuZsTuDpEuHkoiPOkfUpkNHnb0SiQcuwhqsGf/7nk7PnsEEyjLizj8577x6XkcSkQhTKvCWKjMzNNvP2JPJ1LaX0nvJm2STwCvnTeboxzQ1RA6dwRLvlC7N5gqNScTH5l/me52mQBOPf5im6XP5K6kpnb4f5nUcEQkTi6AG68/Xp3Lw3SeTTBazOlzMZf9TcyUi/5WcncZRjKVz+rigb3v7X9uZ0+B4ui95k72UYeadn3P0W2cFfT/RTA2WeGp7w3YAZE//zeMkBzbv/d/oPuF/AOx88lXKVivjcSIRCZeXT/yGMuxlRaNenuZY8vV86lzcn7LsZWKT8+jxqyY3F5H8JW7bzFj68q47K6hzDf81dilbWnTmiK2j2WzV+evNcXT834Dg7SBGqMEST7l2hwOQuvB3j5PsX/qONJIvOpdkspjQ9moOu6aX15FEJJzKlCGNMmRkJ3oWYc2UVaQOOoYqbivTapxApzmvanoIEdkvS/GPIlia9KBdJvjLtztJPboLTTIWsLh0a9ImTKPV+R2Ds/EYo+osnqp+jP8MVq31v+MidI73cSc9RbP0uSxLbk770Y94HUdEwixnMJtQ3ctQkM3rs9jTqz91slczu3xXWs8dSVIZjbAjIgdQOrgN1uuvw1EDK/Cgu4PpNfpTa+kk6mlaiP1SgyWeqtL3cD5KOYd3ss9i+XKv0/zXtGlw6oRreInL2PPC26RWS/U6koiE2TFT7mciXak3f3TY971tGxzdL4l70+9gXko7Gsz6WnVIRAoWpAYrOyObR4cuZuhQyMqC5Buu4fDVX1O+boUgBY1NarDEU1ajOm/2eoeXuYzfI+wqwT174NxzYZcrx7KbX+TQi0M9k4SIRKLqOxbTlcmk7Fgf1v3u2gX9+sEff8CMpmdQedE0KjXScOwiUgiBYQRLkUlGWvEG6Nm9fjczGgzm4tePpGXiYl59FZ540khMVvtQEH2FxHPt/FcJRlyD9f6AkaxauIdDDoH77/c6jYh4xSX7jwRbenrY9rl3815+bzSY7KnTadAAxo6F2vU1s4qIFJIZ6fibrMw9GUVefc2UVaxu1I0jN3xFgjnef3I9Q4cGO2TsUoMlnutw8G6O5xtSv/3Y6yh/m3zrl1zy0xBmWAc+fCeTlBSvE4mIV1yy/02KZYSnwUrbkc7cloPpseVzPkg6l59GZ9OgQVh2LSIxJMP8B4ey9hStdv3x7ARKdWlPy7RZLE9uxvbvp3L4td1DETFmqcESz3UsP59vOJHTZ98ZEQNdrJu+mpaPXwjAloFDOfRw3UwuEs9cKf+bFDKKfhS4qDL3ZvJHi9PpsOUHNll1Er/4jCbNvRu9UESi18CD/qABK0gvVb5Qr3c+x/hTn+eQa/tQ3W1kZpW+VF4whYbHNA9x0tijBks8V+f4duyxsjTxLWbRhPDe45BXdkY2G48+iypuKzOq96Prx9d5mkdEvOcC9zJYZmjPYGXuzWR6i7PotOFLtlllto0cTePjDw7pPkUkdm0o25hVNCAzu+C3+2lpcPspi+nyyfUkk8W49jfRZs0oKjWuEoaksUcNlnjOkpNYWqMLACveneBplonH/Y82OyawPqE2B/38luaZEREInMGyzNCdwcrYncHMpqfTZfXH7KAC6978geantgnZ/kQk9gWODRV48n31aujRAx79vDnXJQ9n8lUf0Gv64ySl6L7P4tK7R4kI+47sBUDiz+EfBjnHtCcm0O3n+/FhrH74PaofUsOzLCISObY3bMs7nMPKCoeGZPvp6XDPsVNpv+4rtlsl1rw5mlbndQjJvkQkfty47iY+YxC2auV+XzPr+V+4ufUopk+Hhg3h4mkX0+W5M8IXMkapwZKIUP3cfgC0+us7nC/8N2KtWAGT7v6eRHxM7nE77W85KuwZRCQyre00mPN4h6l1BgV922lpMGgQPDq5OxeX+5B1746l1fkdg74fEYk/HXeNYRBf4DZv+c9zzucYP+gZWl19FC/tGMJZnZcxfTq0bRv+nLFI5/4kIjQa1Jb1CbWp7VvLok9nh/XSmPR0OPVUmJ72EDsP78Tdo/uHbd8iEvmSA+PclGSyzvzs3byXG05czKgpbahWDa4bcyoH66pAEQmSrAT/5c2+ff++f3THiu3M73IhPdd+DsDvRwzlrZ8akKQRk4NGZ7AkIliCsbhpf+bSiqnf/fdISyjdfNU+pk+Hgw6Cq0cPIKGUjjuIyD/KZOygFXOpsGNV0La5ffk2Fjc5lsemdOfYytP4+Wdoo+ZKRIIoZwTUHZv+abAWfPAb25seQae1n7ODCvx60yf0mvGk7rcKMjVYEjF2PjKc1szl/+aE7/K8n854latea0ObpLl88glU0WA5IpJHgxmfMpfWnDbv3qBsb/1va9l0cA/a7JzI7sSKvPBuBVq3DsqmRUT+llihLABbFm/DORh70Qc0OqszB2UtY36Zdmwf+xudHz/Z45SxSQ2WRIyjjitFairMnAmrgnegeL+mPfADPUZcTnMW88IF02nfPvT7FJHok5DiPwqcmFXyYdqXf7+QrI5daJb+J0tLtcRNnEyT41uWeLsiInmltzgMgOzpvzFkCNz2RjMAxre6nEZrJ3PQUU28jBfT1GBJxChTBvr3h0YsY/z/fgnpvhZ/MouD7zmFJLKZ0OU2ur5yfkj3JyLRy0r7xzpOKmGDNe/t6ZTv34162Sv4s+yRVJozkbqd6gcjoojIfyR18Q+Yk7B0ER99BPPLduCHJ+fSc+5wUirphqtQUoMlEeWGTpNZRhO6vXkhLtsXkn2smbqackOOpzy7mdxgCN0nPBiS/YhIbEgoEziDlV38ebC+eGcntc4/lmpuM9Oq9aPRsrFUbV41WBFFRP6j3uldSacUw7mCbt1g9mwYcENTr2PFBTVYElE6XtWR1YkNaJi5hNmPfR/07W/+cz0Z3ftQO3sNf1TozuGzNZmwiBxYQor/DFZidtHPYDkH998Pg86rwJW8wPjmQ2n715eUrVE22DFFRP6lQvNapE36jeE/Hcy4cdC4sdeJ4ofeWUpESSydxPzeVwKQ+dSzQd32tm3wfP/vaJS5iIUpbWj0xxekVCwd1H2ISOzJOYOVXMQGa+/G3dx39ETuvRfMoP0TZ9BjwauUKpscipgiIv9RscshtO5dncREr5PEFzVYEnEOHz6UvZSh/eYfmPf29KBsc+NG6N0b7lt1IbfUfJvKM0ZTsZGGDBSRgiWWCZzB8hX+EsEln81mff323DL2GLqnzuTrr+HGG/2NloiIxDY1WBJxqjarwrSOVwOQcd0tOJ8r0fbWT1jEhUfOZdYsaN4crp5+LjUOqR6MqCISB7JbHUp3JnBPzVcKfK3zOSaf9zL1Tu5I44yFrC7dhNdHlOX448MQVEREIoIaLIlIh31wG9usMm23j2PC1R8XezvzX55Acu+uvPTXsRzdchUTJkB9DdolIkWQWLkCE+nO/MQDT1a1YcYqfqtzPF3euYwU0hnfbCh1V02l2Ykahl1EJJ5EVYNlZqeb2Wdmts7MnJmdX4R1u5rZVDPbZ2bLzeyaEEaVEqrSpDLzz3uELxnARe/2YtGiIm7AOWac/jjNLjuKqr7NrKncmhE/VKZmzZDEFdkv1a3ol5rq/7hjR/7PZ2XBd9d8T5kOh3DEhlFsoxITLn2fnotepWz11PAFFQki1S6R4ouqBgs4BWgIfFOUlcysKfADsBw4HngZeMrMhgY7oARP59cv5p1BX7B0Vw1OPBHWrCncett+/4s/6vSn/Ue3kEQ2P7S9lXarv6FKg3KhDSySP9WtKFenwm6eT76OOzddy6aN/1yy7PPBV19BmzZw5XMtSCGNSTUHs2/mfHq8dKaHiUWCQrVLpJiSvA5QRKc753xmVg4oyi/qzcBa4GznXBbwk5k1AO41s9edcyW7yUdCwhKMt96Gpctg/qx0prS4hMav3k67M/K/3GbfPhh/wVt0H3klbdnLNiox/cq3Ofb5AWFOLvIvqltRzsqVZQgjqMoGpn1/Oek1sljx7BcwfgID936PI4HGjRvx01WzOPa6gzWQhcQK1S6RYoqqBss5V9yZZ/sBHwR+0XOMAC4HWgNzSppNQqN8eRg7Fj5v8zAnr3mHjDM/ZMwd51FqyCBqdW4M6emsWun4aFFbRo6E9jvqcRx7+anGEJp89TTHHFnL6/+CxDnVrRhgxvK63an61yd0PO9gAOoFnjqj2hg63HkMl18OpUsf7F1GkSBT7RIpvqhqsIrDzMoC9YEFeZ6aH/jYEv2yR7SqVeHs329kep9VHDHnTfr+9Ro88trfz6+gL68wGoBdHfow8dzf6X1lWx1FlqiluhV5ki8+n313fkMZ0thgNZl3UH+SzziFt+7tS7Km0xMBVLtEcsR8gwVUCnzcnmf5tsDHyvmtZGaXAJcANGjQIBS5pAhSqpenw+zX2TjuRhbf9z7lZ02i4p41ZFopfFXrc89QOO00OOQQA9p6HVekpCoFPm7Ps1x1yyNt7jiePRdvYe3aPdRqXY3eiTqCI5KPSoGP2/Ms32/tUt2SWORpg2VmFYHaBb3OOZf3SEhx7O+a33yXO+deAV4BaN++va4XjhA1erWiRq8H/7WsKXCsN3EkDqluxa+y1VM1KqBErUitXapbEou8PoN1KvBqIV5XkkOF2wMfK+VZXjnP8yIihaG6JSLRSLVLJEw8HabdOfeac84KepRwH3uAVfiv+80t5/NgHKkRkTihuiUi0Ui1SyR8om0erOIaBQwys8Rcy07HXwT+9CaSiMgBqW6JSDRS7ZK45/UlgkViZq2AVkBKYFF7M9sNbHLOjQ+8picwFuiTswx4HDgLeNfMXgU6AJcCl2s+BhEJJdUtEYlGql0ixRdVDRZwGnBvrs+vDDzGA70CywxIJNc1xM65JWZ2HPAU/iMr64EbnXOvISISWqpbIhKNVLtEisl0MKFg7du3dzNmzPA6hki+zGymc6691zkksqhuSSRT3ZL8qG5JJCtK3VKDVQhmtglYsZ+nqwGbwxinsCI1F0RutmjNdZBzrnq4wkh0KKBuQfT+vHtFuYpGdUuKTHUr6CI1F0RutgPlKnTdUoNVQmY2IxKPwkVqLojcbMol8SRSf66Uq2iUS+JJpP5cKVfRRWq2YOWKl1EERUREREREQk4NloiIiIiISJCowSq5V7wOsB+RmgsiN5tySTyJ1J8r5Soa5ZJ4Eqk/V8pVdJGaLSi5dA+WiIiIiIhIkOgMloiIiIiISJCowSoiMzvdzD4zs3Vm5szs/CKs29XMpprZPjNbbmbXBDnbxWa22MzSzGymmfUpxDrDAv+PvI/jirH/VmY21sz2mtlaM7vfzBILsV5FM3vTzLaZ2Q4ze9/MqhZ1/8HMZWYN9/N1GRHEXE3N7GUzm2Vm2WY2rpDrhfTrJbFHdeuA21LdKlou1S0Ji0iuW4F9eFa7IrVuFTdbLNaupBInjj+nAA2Bb4ChhV3JzJoCPwTWux3oCDxlZnuDMbu5mQ0BXgKGAROBC4BvzKyDc+7PAlbfAeT95Z5fxP1XBsYA84CTgCbAk/ib+LsKWH0k0AL/19MHPAp8AXQvSoYQ5AK4CZiU6/NgztlwCNAfmAKUKsJ6Ift6ScxS3cp//6pbRae6JeESkXUrsA/Palek1q0gZINYql3OOT2K8AASAh/LAQ44v5DrvQwsApJyLRsOrCJwL1wJcy0E3sidE5gDvFfAesOAzUHY/+3ANqBCrmW3AHtzL8tnvc6Br2OPXMs6Bpb19TBXw0CGE0L9sxT49yfAuEKsE9Kvlx6x+VDd2u92VLeK+bMU+Lfqlh4he0Rq3Qpsz7PaFal1q4TZYq526RLBInLO+Yq5aj/gM+dcVq5lI4B6QOuSZDKzxkBz4KOcZYGcHwf2Gw79gB+ccztzLRsBlAF6FrDeBufchJwFzrlpwHKCk724uUKumD9Lof56SQxS3dov1a0iUt2ScInEugURUbsitW6VJFvIhbt2qcEKAzMrC9QHFuR5KueUcMsS7iJn/fy2X8XMqhewfiUz22xmmWb2u5kNLmaGf+3fObcS/1GLA/3//rNewPwC1gt1rhxvBq7VXWdmT5lZmSBkKolQf71EANUtVLeCSXVLwiIMdSv3NryqXZFat0qSLUfM1C41WOFRKfBxe57l2wIfK5dw+znrF2f7S/Cfvj0NOBlYC3xajF/4yvnsPyfDgfZf3PUKq7jbTwdeAC4C+uC/5OBy/EdivBTqr5dIjkqBj9vzLFfdUt0qKtUtCZdKgY/b8ywPVt3KvY3i7CMYtStS61ZJ9hFztSvuB7kws4pA7YJe55zLr4Mtqv1NOvaf5cXMlXc7VsB+cc69l2e/XwOTgXuAzwraf97N5bPMDrT/Eq5XWEXevnNuHXBVrkXjzGwDMNzM2jrn/ghStuII9ddLIpzqlupWviuobkkEi9S6BVFZuyK1bhVrH7FYu+K+wQJOBV4txOus4Jfs1/bAx0p5lu/vKAgULVfOUZNK+EenIdfn+9t+vpxzzsw+Ax41s0TnXHYhV93Gf/9/ABUL2P82IL/T6ZUKWK+wipsrP5/gv1H2cOCPkoQqgVB/vSQ6qG7lorp1QKpbEikitW5BdNWuSK1bOfuolM/yuKtdcX+JoHPuNeecFfQo4T724B+9Ju/1mvu7jreouRbk2V7u7W91zm0qTuwivn5B3v2bWX2gLPlfv7rf9QL2d91rURU3V35cno9eCPXXS6KA6tb+Yxfx9apb4aG6JRFbt4qRzevaFal1qyTZ8hPVtSvuG6wwGgUMyjPZ2un4C0FBcyYckHNuGf4hSU/NWWZmCYHPRxVlW2ZmwCBgVhGOAhPYz7FmVj7XstOBfcD4AtarZWbdcmVoDzSmiNmDnCs/pwQ+zgxCruIK9ddLJDfVrf2vp7pVeKpbEk4hq1sQEbUrUutWSbLlJ7prlwvRePOx+gBa4f+mn42/q34+8HnPXK/pCWTlWdYU2A18APTGf5NjJjA0SLnOALLxT+TWG3gL/w906wJyjQeuAY7B/0v+Hf6J1AYUcf+VgXXAaKAvcEng//u/PK9bAryeZ9n3wDJgMDAQ//wSvwTp61KsXPjnqngykKkvcH/g6/lpEH+WUgM/O6cAvwJzc32e6sXXS4/YfKhu7Xf/qltFz6a6pUdYHpFatwL78Kx2RWrdKkm2WKxdnv8CRdsj8EPg8nmMy/WaXoFlvfKs2w2YBqQBfwHXBDnbxYEfjnTgN6BPnuf/kwt4PfCDsw/YA/wC9Cvm/lsBPwW2tQ54AEjM85q/gLfyLKsEvIn/etad+ItitSB+XYqcCxgCzMB/fXVG4Ot6P1A6iLka7udnyQENvfp66RF7D9WtA+5fdatouVS39AjLI5LrVmAfntWuSK1bxc0Wi7XLAiuLiIiIiIhICekeLBERERERkSBRgyUiIiIiIhIkarBERERERESCRA2WiIiIiIhIkKjBEhERERERCRI1WCIiIiIiIkGiBktERERERCRI1GCJiIiIiIgEiRosERERERGRIFGDJSFnZj3NzJlZv1zLGpnZRjN71stsIiL5Ud0SkWik2hUZzDnndQaJA2b2E5DinOtiZhWBycBy4CTnXLa36URE/kt1S0SikWqX99RgSViYWXdgAnAscCNQE+jmnNvtaTARkf1Q3RKRaKTa5T01WBI2ZjYa6AJsB450zq32NpGIyIGpbolINFLt8pbuwZJwWgKkAvfqF11EooTqlohEI9UuD+kMloSFmV0CPAfMB9Kcc508jiQickCqWyISjVS7vKcGS0LOzI4GvgWGAouAX4H+zrlRngYTEdkP1S0RiUaqXZFBDZaElJkdAkwCnnfO3RVYNhqo6Jzr6Gk4EZF8qG6JSDRS7YocarAkZMysBjAVmAGc5gI/bGbWAxgPnOCc+9bDiCIi/6K6JSLRSLUrsqjBEhERERERCRKNIigiIpjZMDNz+3mcHeYsl5jZwHDuM1bk831ca2afmlmTEO3vhMB+GgY+bxj4/IQibOM0Mzs/n+XjzOyT4KUVEQmPJK8DiIhIxNgBHJfP8iVhznEJ8CfwRZj3Gytyfx8bAw8AY83sEOfcnhDvex3QGVhQhHVOA6oBb+VZfgWQGZxYIiLhowZLRERyZDnnpngdQkos9/dxipmtBH4B+gMf536hmZVxzu0L1o6dc+lAUH6GnHPzgrEdEZFw0yWCIiJSIDO72czSzKxVrmUdzSzLzIYGPi9rZs+b2UIz22tmy83sBTOrkGdbiWZ2u5ktMrN0M1ttZm8FnhsHHAGcl+syt/PD9h+NTTMDHxua2V9m9qSZ3W1mq4GdAGaWYGa3mdmSwPdkkZmdl3sj5jfMzDaa2S4zewfI+73N9xJBM7vYzOYEfoY2mNknZlYx8H0/GeiZ6/s9LLDOfy4RNLOjzGxqru0MN7NyuZ7vFdhGLzP72Mx2m9kyM7siKF9JEZFC0BksERH5m5n95++Ccy4LeBI4CXjbzDrj//vxNvCjc+61wEtTgUTgTmATUD/w74+BY3Nt8mXgXOAx/KNbVQFOCTx3BfApsAz/pW0AS4P034tXDQMf1wc+ngnMxf+1zvl+PwecB9wP/AYcDbxhZlucc98EXnMNcA/wEP4zYoPxfw8PyMzuCmx3OHAz/p+T44Fy+L/HDYBKgTwAq/eznVbA98Bo/E1ZfeAR/JdB5r209VX8P5+vAGcAL5jZDOfctILyioiUlBosERHJUZV87nkxs0bOub8CZ5L+AG4HKgM1gT45r3PObQIuz7VeErAcmGhmDZxzK82sJXARcK1z7tlcuxkZ2MY8M9sDbNLlisWXq1FujL+x2QWM4Z+m9QTnXFrgtU3xf98ucM69HXh+jJnVBu4FvjGzROBW4OWc+XWAHwJz7NQ9QI5KwB3AM865G3I99Vmu12wFEgrx/b4HWAEMcM5l51p3pJl1ds79muu1Hzrn/hd4zTjgRPwNoRosEQk5XSIoIhICZjgvH8WMvQPokM9jLYBzbgn+N9l3A9cCVzvn1v77/23nmNnvZrYbf7M2MfBU88DH3oGPbxUzY3iZuQM8Lsn1uksO+Np/b3PmAV77ShBS5zTKmcBC/E3W6c65dYHnx+Y0VwF9AB/wuZkl5TyAsUDbQHNVH6gNfJlnX59xYJ2BMsCbJfkPBXQEPs9prgI+BbKAbnle+2POP5xzmcBioF4QMoiIFEhnsEREJEeWc25GAa/5FHga2Mp/B0wYBLwDvIj/rMVW/G/KPwdSAi+rCuxxzu0MYm75tx1AX8Dhvyxwbc6kowEb8ry+Gv5LO3fsZ3u1gVqBf2/M81zez/OqGvi47oCvKpza5MnunMs2sy34LzPNbXuezzP452dQRCSk1GCJiISAc5jXGULkZWAlUAMYhr+RynEqMNU59/eAAmbWM8/6W4CyZlYhKpos5wr3fXTuFfz3+xTmtUeUIFFhFNQo5z3DuRX/WaCu+M9k5bWRf94v1MjzXN7P89oS+Fgb2FzAawuyLu/+AmfXquL/P4iIRARdIigiIoViZufiH5zgbOBG4BYz65jrJWWA9DyrnZXn858CH889wK50tiG8fsJ/Bquic25GPo8MYBX+s2En5Vl3cAHb/hXYh38Ajf0p7Pd7KjAo0FTl3n8S/1yKKiLiOZ3BEhGRHElm1imf5asAA/4PeDwwGMEUMxuMf1TBdoF7ekbjH63tTvxvhvuTaxAMAOfcQvPfZ/SkmdUAJuAfQe4U59yQwMsWAMea2bH4z4Asd85tQUIi8D15CRhhZo8BM/A3PIcAzZ1zQwOX4j0GPGFmm/GPIngycHAB295uZg8AD5pZKeA7oDT+Rv0+59wa/N/vk8xsIP4RBNfmvbcv4H/A78AXZvYi/nuqHgV+yDPAhYiIp9RgiYhIjor4zzjkdTf+QQRW4x9VLsdQ4E/gQfxntF7GP6DCtfjfoI/GPyR43tHhrsA/GtxQ4Db8l6CNzvX8//AP3f0R/nmWLiBaBsWIXlcCi4CL8Q+pvhOYB7ye6zXP4L/X6TLgOuAr4Bbg/QNt2Dn3cGC0v2uBS4Ft+BvrXYGXDAfaAW/gH53yPvyXn+bdzlwz64d/mPjPAhk/DGQQEYkY9u/7XkVERERERKS4dA+WiIiIiIhIkKjBEhERERERCRI1WCIiIiIiIkGiBktERERERCRI1GCJiIiIiIgEiRosERERERGRIFGDJSIiIiIiEiRqsERERERERIJEDZaIiIiIiEiQqMESEREREREJEjVYIiIiIiIiQaIGS0REREREJEjUYImIiIiIiASJGiwREREREZEgUYMlIiIiIiISJP8PkQbt/mlqzTcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "####### Row 1: u(t,x) slices ################## \n",
    "\n",
    "\"\"\" The aesthetic setting has changed. \"\"\"\n",
    "\n",
    "fig = plt.figure(figsize=(14, 10))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "gs1 = gridspec.GridSpec(1, 3)\n",
    "gs1.update(top=1-1.0/3.0-0.1, bottom=1.0-2.0/3.0, left=0.1, right=0.9, wspace=0.5)\n",
    "\n",
    "ax = plt.subplot(gs1[0, 0])\n",
    "ax.plot(x,Exact[25,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "ax.plot(x,U_pred[25,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$u(t,x)$')    \n",
    "ax.set_title('$t = 0.25$', fontsize = 15)\n",
    "ax.axis('square')\n",
    "ax.set_xlim([-1.1,1.1])\n",
    "ax.set_ylim([-1.1,1.1])\n",
    "\n",
    "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
    "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "    item.set_fontsize(15)\n",
    "\n",
    "ax = plt.subplot(gs1[0, 1])\n",
    "ax.plot(x,Exact[50,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "ax.plot(x,U_pred[50,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$u(t,x)$')\n",
    "ax.axis('square')\n",
    "ax.set_xlim([-1.1,1.1])\n",
    "ax.set_ylim([-1.1,1.1])\n",
    "ax.set_title('$t = 0.50$', fontsize = 15)\n",
    "ax.legend(\n",
    "    loc='upper center', \n",
    "    bbox_to_anchor=(0.5, -0.15), \n",
    "    ncol=5, \n",
    "    frameon=False, \n",
    "    prop={'size': 15}\n",
    ")\n",
    "\n",
    "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
    "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "    item.set_fontsize(15)\n",
    "\n",
    "ax = plt.subplot(gs1[0, 2])\n",
    "ax.plot(x,Exact[75,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "ax.plot(x,U_pred[75,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "ax.set_xlabel('$x$')\n",
    "ax.set_ylabel('$u(t,x)$')\n",
    "ax.axis('square')\n",
    "ax.set_xlim([-1.1,1.1])\n",
    "ax.set_ylim([-1.1,1.1])    \n",
    "ax.set_title('$t = 0.75$', fontsize = 15)\n",
    "\n",
    "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
    "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "    item.set_fontsize(15)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 原文结果\n",
    "\n",
    "下图总结了我们对Burgers方程的数据驱动解决方案的结果。\n",
    "\n",
    "![img](https://maziarraissi.github.io/assets/img/Burgers_CT_inference.png)\n",
    "\n",
    "\n",
    "\n",
    "> *Burgers方程*：**顶部**：预测解以及初始和边界训练数据。此外，我们使用10000个搭配点，这些搭配点是使用**拉丁超立方体采样策略**( Latin Hypercube Sampling strategy)生成的。**底部**：与顶部面板中白色垂直线描绘的三个时间快照相对应的预测解和精确解的比较。在一张NVIDIA Titan X GPU卡上进行模型培训大约需要60秒。\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3.6",
   "language": "python",
   "name": "py3.6"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
